Jassif Team Institution

let MongoClient = require('mongodb').MongoClient;
let url = "mongodb://localhost:27017/";

MongoClient.connect(url, function(err, db) {
  if (err) throw err;
  let dbo = db.db("mydb");
  dbo.createCollection("customers", function(err, res) {
    if (err) throw err;
    console.log("Collection created!");
    db.close();
  });
});

C:\Users\Your Name>node demo_mongodb_createcollection.js

Collection created!

const { MongoClient } = require('mongodb');

async function createCollectionModern() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    // Create collection explicitly
    const collection = await database.createCollection("customers");
    console.log("Collection created successfully:", collection.collectionName);
    
  } catch (err) {
    console.error("Error creating collection:", err);
  } finally {
    await client.close();
  }
}

createCollectionModern();

const { MongoClient } = require('mongodb');

async function autoCreateCollection() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    // Collection will be created automatically on first insert
    const collection = database.collection("customers");
    
    // Insert first document - this creates the collection
    const result = await collection.insertOne({
      name: "John Doe",
      email: "john@example.com",
      createdAt: new Date()
    });
    
    console.log("Collection created automatically with first document");
    console.log("Document inserted with id:", result.insertedId);
    
  } catch (err) {
    console.error("Error:", err);
  } finally {
    await client.close();
  }
}

autoCreateCollection();

const { MongoClient } = require('mongodb');

async function createCappedCollection() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    // Create a capped collection (fixed size)
    const collection = await database.createCollection("logs", {
      capped: true,
      size: 1000000, // 1MB in bytes
      max: 1000      // Maximum 1000 documents
    });
    
    console.log("Capped collection created successfully");
    
  } catch (err) {
    console.error("Error creating capped collection:", err);
  } finally {
    await client.close();
  }
}

createCappedCollection();

const { MongoClient } = require('mongodb');

async function createValidatedCollection() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    // Create collection with validation rules
    const collection = await database.createCollection("users", {
      validator: {
        $jsonSchema: {
          bsonType: "object",
          required: ["name", "email"],
          properties: {
            name: {
              bsonType: "string",
              description: "must be a string and is required"
            },
            email: {
              bsonType: "string",
              pattern: "^.+@.+\\..+$",
              description: "must be a valid email and is required"
            },
            age: {
              bsonType: "int",
              minimum: 0,
              maximum: 150,
              description: "must be an integer between 0 and 150"
            }
          }
        }
      }
    });
    
    console.log("Validated collection created successfully");
    
  } catch (err) {
    console.error("Error creating validated collection:", err);
  } finally {
    await client.close();
  }
}

createValidatedCollection();

const { MongoClient } = require('mongodb');

async function listCollections() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    const collections = await database.listCollections().toArray();
    
    console.log("Collections in database:");
    collections.forEach(collection => {
      console.log(` - ${collection.name}`);
    });
    
  } catch (err) {
    console.error("Error listing collections:", err);
  } finally {
    await client.close();
  }
}

listCollections();

const { MongoClient } = require('mongodb');

async function checkCollectionExists() {
  const uri = "mongodb://localhost:27017/";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("mydb");
    
    const collections = await database.listCollections().toArray();
    const exists = collections.some(col => col.name === "customers");
    
    if (exists) {
      console.log("Collection 'customers' exists");
    } else {
      console.log("Collection 'customers' does not exist");
    }
    
  } catch (err) {
    console.error("Error checking collection:", err);
  } finally {
    await client.close();
  }
}

checkCollectionExists();

const { MongoClient } = require('mongodb');

class CollectionManager {
  constructor(connectionString, dbName) {
    this.connectionString = connectionString;
    this.dbName = dbName;
    this.client = new MongoClient(connectionString);
  }

  async connect() {
    try {
      await this.client.connect();
      console.log("Connected to MongoDB server");
      this.database = this.client.db(this.dbName);
      return true;
    } catch (error) {
      console.error("Connection failed:", error);
      return false;
    }
  }

  async createCollection(collectionName, options = {}) {
    try {
      const collection = await this.database.createCollection(collectionName, options);
      console.log(`Collection '${collectionName}' created successfully`);
      return collection;
    } catch (error) {
      console.error(`Error creating collection '${collectionName}':`, error);
      throw error;
    }
  }

  async getOrCreateCollection(collectionName) {
    try {
      // Check if collection exists
      const collections = await this.database.listCollections().toArray();
      const exists = collections.some(col => col.name === collectionName);
      
      if (exists) {
        console.log(`Collection '${collectionName}' already exists`);
        return this.database.collection(collectionName);
      } else {
        return await this.createCollection(collectionName);
      }
    } catch (error) {
      console.error(`Error getting/creating collection '${collectionName}':`, error);
      throw error;
    }
  }

  async listAllCollections() {
    try {
      const collections = await this.database.listCollections().toArray();
      console.log(`Found ${collections.length} collections:`);
      collections.forEach(collection => {
        console.log(` - ${collection.name}`);
      });
      return collections;
    } catch (error) {
      console.error("Error listing collections:", error);
      throw error;
    }
  }

  async close() {
    try {
      await this.client.close();
      console.log("Connection closed");
    } catch (error) {
      console.error("Error closing connection:", error);
    }
  }
}

// Usage example
async function main() {
  const connectionString = "mongodb://localhost:27017/";
  const dbName = "mydb";
  
  const collectionManager = new CollectionManager(connectionString, dbName);

  try {
    const connected = await collectionManager.connect();
    if (!connected) return;

    // Create a regular collection
    await collectionManager.createCollection("users");
    
    // Create a collection with validation
    await collectionManager.createCollection("products", {
      validator: {
        $jsonSchema: {
          bsonType: "object",
          required: ["name", "price"],
          properties: {
            name: { bsonType: "string" },
            price: { bsonType: "double", minimum: 0 }
          }
        }
      }
    });
    
    // Get or create collection (idempotent)
    const customersCollection = await collectionManager.getOrCreateCollection("customers");
    
    // List all collections
    await collectionManager.listAllCollections();
    
    console.log("Collection setup completed successfully!");
    
  } catch (error) {
    console.error("Main function error:", error);
  } finally {
    await collectionManager.close();
  }
}

// Run the example
main();